package cn.good.yan.b8.f2;

import cn.good.yan.b8.f1.Uo;

import java.io.*;

/**
 * b8 文件 File
 *    流操作
 *      输入流 - 读取外部数据（磁盘）到程序中 （内存）
 *      输出流 - 将程序中 （内存）写入到 磁盘 中
 *
 * @author shengren.yan
 * @create 2023-08-01
 */
public class Test {

    /**
     *  抽象基类       节点流              缓冲流（处理流）       转换流
     *  InputStream    FileInputStream    BufferedInputStream   InputStreamReader
     *  OutputStream   FileOutputStream   BufferedOutputStream  OutputStreamWriter
     *  Reader         FileReader         BufferedReader
     *  Writer         FileWriter         BufferedWriter
     */
    public static void main(String[] args) throws Exception{
        Test t = new Test();
    }

    /**
     * 将 file1 文件里的内容，读到 file2中 （文件复制）
     *
     * @throws Exception 异常
     */
    public void t1() throws Exception {
        File file1 = new File("路径1");
        File file2 = new File("路径2");
        // 创建流
        FileInputStream fis = new FileInputStream(file1);
        FileOutputStream fos = new FileOutputStream(file2);

        // 读文件内容 值 或者 2048
        byte[] buffer = new byte[1024];
        int len; // 每次读到buffer中字节个数
        while ((len = fis.read(buffer)) != -1) {
            // 读到哪里，写到哪里
            fos.write(buffer, 0, len);
        }
        fos.close();
        fis.close();
     }

    /**
     * 将 file1 文件里的内容，读到 file2中 （文件复制） - 使用缓冲流
     *
     * @throws Exception 异常
     */
    public void t2() throws Exception {
        File file1 = new File("路径1");
        File file2 = new File("路径2");
        // 创建流
        FileInputStream fis = new FileInputStream(file1);
        FileOutputStream fos = new FileOutputStream(file2);
        // 创建缓冲流 （提示读写速度，减少与磁盘交互的次数）
        BufferedInputStream bis = new BufferedInputStream(fis);
        BufferedOutputStream bos = new BufferedOutputStream(fos);

        byte[] buffer = new byte[1024];
        int len; // 每次读到buffer中字节个数
        while ((len = bis.read(buffer)) != -1) {
            bos.write(buffer, 0, len);
        }
        // 外层关闭
        bos.close();
        bis.close();
        // 内层关闭
        fos.close();
        fis.close();
    }

    /**
     * 将 file1 文件里的内容，读到 file2中 （文件复制） - 使用字节流 转换 字符流
     *
     * @throws Exception 异常
     */
    public void t3() throws Exception {
        File file1 = new File("路径1");
        File file2 = new File("路径2");
        // 创建流
        FileInputStream fis = new FileInputStream(file1);
        FileOutputStream fos = new FileOutputStream(file2);
        // 将字节流 转换 字符流
        InputStreamReader isr = new InputStreamReader(fis,"utf-8");
        OutputStreamWriter oos = new OutputStreamWriter(fos,"utf-8");

        BufferedReader bf = new BufferedReader(isr);
        BufferedWriter bw = new BufferedWriter(oos);

        char[] buffer = new char[1024];
        int len; // 每次读到buffer中字节个数
        while ((len = bf.read(buffer)) != -1) {
            bw.write(buffer, 0, len);
        }
        bw.close();
        bf.close();
        oos.close();
        isr.close();
    }

    // 4.对象流
    // 对象序列表：将对象以二进制形式保存到磁盘中的过程就是。 对象反序列化：将磁盘中的数据读回对象中。
    public void t4() throws Exception{

        // 注意 实体需要实现  Serializable 接口 、不能序列化static和transient修饰的成员变量
        Uo o1 = new Uo("A",1);
        // 1. 对象序列化
        ObjectOutputStream oos = null;
        try {
            BufferedOutputStream bs = new BufferedOutputStream(new FileOutputStream("打开指定文件路径1/xx.dat"));
            oos = new ObjectOutputStream(bs);
            oos.writeObject(o1);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            oos.close();
        }

        // 2. 对象反序列化
        ObjectInputStream ois = null;
        try {
            BufferedInputStream bi = new BufferedInputStream(new FileInputStream("打开指定文件路径1/xx.dat"));
            ois = new ObjectInputStream(bi);
            Uo object = (Uo) ois.readObject();  // 得到对象的反序列化
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            oos.close();
        }
    }

    // 5.转换流
    // 编码：字符串 - 字节数组   解码：字节数组 - 字符串
    public void t5() throws Exception{
        // 解码
        InputStream in = System.in;
        InputStreamReader isr = new InputStreamReader(in,"utf-8");
        BufferedReader bi = new BufferedReader(isr);
        // 编码
        String str = "SSS是";
        FileOutputStream fos = new FileOutputStream("/xxx.txt");
        OutputStreamWriter osw = new OutputStreamWriter(fos,"utf-8");
        BufferedWriter bf = new BufferedWriter(osw);
        bf.write(str);
        bf.close();
    }


}
